home *** CD-ROM | disk | FTP | other *** search
/ Aminet 44 / Aminet 44 (2001)(GTI - Schatztruhe)[!][Aug 2001].iso / Aminet / comm / mail / YAM23src.lha / Source / YAM_gates.c < prev    next >
C/C++ Source or Header  |  2001-05-02  |  48KB  |  1,480 lines
  1. /* FILE GENERATED BY gen_gates.pl - DO NOT EDIT */
  2. #include <exec/types.h>
  3. #include <emul/emulinterface.h>
  4. #include <emul/emulregs.h>
  5. typedef void *Msg;
  6. typedef struct { long dummy; } Object;
  7. void AY_SendMailFunc(void);
  8. static void  Trampoline_AY_SendMailFunc(void)
  9. {
  10.    AY_SendMailFunc();
  11. }
  12. const struct EmulLibEntry Gate_AY_SendMailFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_AY_SendMailFunc };
  13.  
  14. void AY_GoPageFunc(void);
  15. static void  Trampoline_AY_GoPageFunc(void)
  16. {
  17.    AY_GoPageFunc();
  18. }
  19. const struct EmulLibEntry Gate_AY_GoPageFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_AY_GoPageFunc };
  20.  
  21. void DoublestartFunc(void);
  22. static void  Trampoline_DoublestartFunc(void)
  23. {
  24.    DoublestartFunc();
  25. }
  26. const struct EmulLibEntry Gate_DoublestartFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_DoublestartFunc };
  27.  
  28. void AB_FromAddrBook(ULONG *arg);
  29. static void  Trampoline_AB_FromAddrBook(void)
  30. {
  31.    AB_FromAddrBook((ULONG *)REG_A1);
  32. }
  33. const struct EmulLibEntry Gate_AB_FromAddrBook = { TRAP_LIBNR, 0, (void(*)())Trampoline_AB_FromAddrBook };
  34.  
  35. void AB_DoubleClick(void);
  36. static void  Trampoline_AB_DoubleClick(void)
  37. {
  38.    AB_DoubleClick();
  39. }
  40. const struct EmulLibEntry Gate_AB_DoubleClick = { TRAP_LIBNR, 0, (void(*)())Trampoline_AB_DoubleClick };
  41.  
  42. void AB_Sort(int *arg);
  43. static void  Trampoline_AB_Sort(void)
  44. {
  45.    AB_Sort((int *)REG_A1);
  46. }
  47. const struct EmulLibEntry Gate_AB_Sort = { TRAP_LIBNR, 0, (void(*)())Trampoline_AB_Sort };
  48.  
  49. void AB_NewABookFunc(void);
  50. static void  Trampoline_AB_NewABookFunc(void)
  51. {
  52.    AB_NewABookFunc();
  53. }
  54. const struct EmulLibEntry Gate_AB_NewABookFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_AB_NewABookFunc };
  55.  
  56. void AB_OpenABookFunc(void);
  57. static void  Trampoline_AB_OpenABookFunc(void)
  58. {
  59.    AB_OpenABookFunc();
  60. }
  61. const struct EmulLibEntry Gate_AB_OpenABookFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_AB_OpenABookFunc };
  62.  
  63. void AB_AppendABookFunc(void);
  64. static void  Trampoline_AB_AppendABookFunc(void)
  65. {
  66.    AB_AppendABookFunc();
  67. }
  68. const struct EmulLibEntry Gate_AB_AppendABookFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_AB_AppendABookFunc };
  69.  
  70. void AB_SaveABookFunc(void);
  71. static void  Trampoline_AB_SaveABookFunc(void)
  72. {
  73.    AB_SaveABookFunc();
  74. }
  75. const struct EmulLibEntry Gate_AB_SaveABookFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_AB_SaveABookFunc };
  76.  
  77. void AB_SaveABookAsFunc(void);
  78. static void  Trampoline_AB_SaveABookAsFunc(void)
  79. {
  80.    AB_SaveABookAsFunc();
  81. }
  82. const struct EmulLibEntry Gate_AB_SaveABookAsFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_AB_SaveABookAsFunc };
  83.  
  84. void AB_PrintABookFunc(void);
  85. static void  Trampoline_AB_PrintABookFunc(void)
  86. {
  87.    AB_PrintABookFunc();
  88. }
  89. const struct EmulLibEntry Gate_AB_PrintABookFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_AB_PrintABookFunc };
  90.  
  91. void AB_PrintFunc(void);
  92. static void  Trampoline_AB_PrintFunc(void)
  93. {
  94.    AB_PrintFunc();
  95. }
  96. const struct EmulLibEntry Gate_AB_PrintFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_AB_PrintFunc };
  97.  
  98. void AB_AddEntryFunc(int *arg);
  99. static void  Trampoline_AB_AddEntryFunc(void)
  100. {
  101.    AB_AddEntryFunc((int *)REG_A1);
  102. }
  103. const struct EmulLibEntry Gate_AB_AddEntryFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_AB_AddEntryFunc };
  104.  
  105. void AB_EditFunc(void);
  106. static void  Trampoline_AB_EditFunc(void)
  107. {
  108.    AB_EditFunc();
  109. }
  110. const struct EmulLibEntry Gate_AB_EditFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_AB_EditFunc };
  111.  
  112. void AB_DeleteFunc(void);
  113. static void  Trampoline_AB_DeleteFunc(void)
  114. {
  115.    AB_DeleteFunc();
  116. }
  117. const struct EmulLibEntry Gate_AB_DeleteFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_AB_DeleteFunc };
  118.  
  119. void AB_DuplicateFunc(void);
  120. static void  Trampoline_AB_DuplicateFunc(void)
  121. {
  122.    AB_DuplicateFunc();
  123. }
  124. const struct EmulLibEntry Gate_AB_DuplicateFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_AB_DuplicateFunc };
  125.  
  126. void AB_FindFunc(void);
  127. static void  Trampoline_AB_FindFunc(void)
  128. {
  129.    AB_FindFunc();
  130. }
  131. const struct EmulLibEntry Gate_AB_FindFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_AB_FindFunc };
  132.  
  133. void AB_OpenFunc(int *arg);
  134. static void  Trampoline_AB_OpenFunc(void)
  135. {
  136.    AB_OpenFunc((int *)REG_A1);
  137. }
  138. const struct EmulLibEntry Gate_AB_OpenFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_AB_OpenFunc };
  139.  
  140. void AB_Close(void);
  141. static void  Trampoline_AB_Close(void)
  142. {
  143.    AB_Close();
  144. }
  145. const struct EmulLibEntry Gate_AB_Close = { TRAP_LIBNR, 0, (void(*)())Trampoline_AB_Close };
  146.  
  147. struct MUIP_NListtree_ConstructMessage;
  148. struct ABEntry * AB_LV_ConFunc( struct MUIP_NListtree_ConstructMessage *msg);
  149. static struct ABEntry *  Trampoline_AB_LV_ConFunc(void)
  150. {
  151.    return AB_LV_ConFunc((struct MUIP_NListtree_ConstructMessage *)REG_A1);
  152. }
  153. const struct EmulLibEntry Gate_AB_LV_ConFunc = { TRAP_LIB, 0, (void(*)())Trampoline_AB_LV_ConFunc };
  154.  
  155. struct MUIP_NListtree_DestructMessage;
  156. long AB_LV_DesFunc( struct MUIP_NListtree_DestructMessage *msg);
  157. static long  Trampoline_AB_LV_DesFunc(void)
  158. {
  159.    return AB_LV_DesFunc((struct MUIP_NListtree_DestructMessage *)REG_A1);
  160. }
  161. const struct EmulLibEntry Gate_AB_LV_DesFunc = { TRAP_LIB, 0, (void(*)())Trampoline_AB_LV_DesFunc };
  162.  
  163. struct Hook;
  164. struct MUIP_NListtree_DisplayMessage;
  165. long AB_LV_DspFunc( struct Hook *hook,  struct MUIP_NListtree_DisplayMessage *msg);
  166. static long  Trampoline_AB_LV_DspFunc(void)
  167. {
  168.    return AB_LV_DspFunc((struct Hook *)REG_A0, (struct MUIP_NListtree_DisplayMessage *)REG_A1);
  169. }
  170. const struct EmulLibEntry Gate_AB_LV_DspFunc = { TRAP_LIB, 0, (void(*)())Trampoline_AB_LV_DspFunc };
  171.  
  172. struct IClass;
  173. ULONG BC_Dispatcher(struct IClass *cl, Object *obj, Msg msg);
  174. static ULONG  Trampoline_BC_Dispatcher(void)
  175. {
  176.    return BC_Dispatcher((struct IClass *)REG_A0, (Object *)REG_A2, (Msg)REG_A1);
  177. }
  178. const struct EmulLibEntry Gate_BC_Dispatcher = { TRAP_LIB, 0, (void(*)())Trampoline_BC_Dispatcher };
  179.  
  180. struct IClass;
  181. ULONG WS_Dispatcher(struct IClass *cl, Object *obj, Msg msg);
  182. static ULONG  Trampoline_WS_Dispatcher(void)
  183. {
  184.    return WS_Dispatcher((struct IClass *)REG_A0, (Object *)REG_A2, (Msg)REG_A1);
  185. }
  186. const struct EmulLibEntry Gate_WS_Dispatcher = { TRAP_LIB, 0, (void(*)())Trampoline_WS_Dispatcher };
  187.  
  188. struct IClass;
  189. ULONG WL_Dispatcher(struct IClass *cl, Object *obj, Msg msg);
  190. static ULONG  Trampoline_WL_Dispatcher(void)
  191. {
  192.    return WL_Dispatcher((struct IClass *)REG_A0, (Object *)REG_A2, (Msg)REG_A1);
  193. }
  194. const struct EmulLibEntry Gate_WL_Dispatcher = { TRAP_LIB, 0, (void(*)())Trampoline_WL_Dispatcher };
  195.  
  196. struct IClass;
  197. ULONG FL_Dispatcher(struct IClass *cl, Object *obj, Msg msg);
  198. static ULONG  Trampoline_FL_Dispatcher(void)
  199. {
  200.    return FL_Dispatcher((struct IClass *)REG_A0, (Object *)REG_A2, (Msg)REG_A1);
  201. }
  202. const struct EmulLibEntry Gate_FL_Dispatcher = { TRAP_LIB, 0, (void(*)())Trampoline_FL_Dispatcher };
  203.  
  204. struct IClass;
  205. ULONG EL_Dispatcher(struct IClass *cl, Object *obj, Msg msg);
  206. static ULONG  Trampoline_EL_Dispatcher(void)
  207. {
  208.    return EL_Dispatcher((struct IClass *)REG_A0, (Object *)REG_A2, (Msg)REG_A1);
  209. }
  210. const struct EmulLibEntry Gate_EL_Dispatcher = { TRAP_LIB, 0, (void(*)())Trampoline_EL_Dispatcher };
  211.  
  212. struct IClass;
  213. ULONG AL_Dispatcher(struct IClass *cl, Object *obj, Msg msg);
  214. static ULONG  Trampoline_AL_Dispatcher(void)
  215. {
  216.    return AL_Dispatcher((struct IClass *)REG_A0, (Object *)REG_A2, (Msg)REG_A1);
  217. }
  218. const struct EmulLibEntry Gate_AL_Dispatcher = { TRAP_LIB, 0, (void(*)())Trampoline_AL_Dispatcher };
  219.  
  220. struct IClass;
  221. ULONG MW_Dispatcher(struct IClass *cl, Object *obj, Msg msg);
  222. static ULONG  Trampoline_MW_Dispatcher(void)
  223. {
  224.    return MW_Dispatcher((struct IClass *)REG_A0, (Object *)REG_A2, (Msg)REG_A1);
  225. }
  226. const struct EmulLibEntry Gate_MW_Dispatcher = { TRAP_LIB, 0, (void(*)())Trampoline_MW_Dispatcher };
  227.  
  228. struct IClass;
  229. struct MUIP_TextEditor_HandleError;
  230. ULONG TE_Dispatcher(struct IClass *cl, Object *obj, struct MUIP_TextEditor_HandleError *msg);
  231. static ULONG  Trampoline_TE_Dispatcher(void)
  232. {
  233.    return TE_Dispatcher((struct IClass *)REG_A0, (Object *)REG_A2, (struct MUIP_TextEditor_HandleError *)REG_A1);
  234. }
  235. const struct EmulLibEntry Gate_TE_Dispatcher = { TRAP_LIB, 0, (void(*)())Trampoline_TE_Dispatcher };
  236.  
  237. struct IClass;
  238. ULONG PL_Dispatcher(struct IClass *cl, Object *obj, Msg msg);
  239. static ULONG  Trampoline_PL_Dispatcher(void)
  240. {
  241.    return PL_Dispatcher((struct IClass *)REG_A0, (Object *)REG_A2, (Msg)REG_A1);
  242. }
  243. const struct EmulLibEntry Gate_PL_Dispatcher = { TRAP_LIB, 0, (void(*)())Trampoline_PL_Dispatcher };
  244.  
  245. void CO_AddRule(void);
  246. static void  Trampoline_CO_AddRule(void)
  247. {
  248.    CO_AddRule();
  249. }
  250. const struct EmulLibEntry Gate_CO_AddRule = { TRAP_LIBNR, 0, (void(*)())Trampoline_CO_AddRule };
  251.  
  252. void CO_DelRule(void);
  253. static void  Trampoline_CO_DelRule(void)
  254. {
  255.    CO_DelRule();
  256. }
  257. const struct EmulLibEntry Gate_CO_DelRule = { TRAP_LIBNR, 0, (void(*)())Trampoline_CO_DelRule };
  258.  
  259. void CO_GetRUEntry(void);
  260. static void  Trampoline_CO_GetRUEntry(void)
  261. {
  262.    CO_GetRUEntry();
  263. }
  264. const struct EmulLibEntry Gate_CO_GetRUEntry = { TRAP_LIBNR, 0, (void(*)())Trampoline_CO_GetRUEntry };
  265.  
  266. void CO_PutRUEntry(void);
  267. static void  Trampoline_CO_PutRUEntry(void)
  268. {
  269.    CO_PutRUEntry();
  270. }
  271. const struct EmulLibEntry Gate_CO_PutRUEntry = { TRAP_LIBNR, 0, (void(*)())Trampoline_CO_PutRUEntry };
  272.  
  273. void CO_RemoteToggleFunc(int *arg);
  274. static void  Trampoline_CO_RemoteToggleFunc(void)
  275. {
  276.    CO_RemoteToggleFunc((int *)REG_A1);
  277. }
  278. const struct EmulLibEntry Gate_CO_RemoteToggleFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_CO_RemoteToggleFunc };
  279.  
  280. void CO_AddPOP3(void);
  281. static void  Trampoline_CO_AddPOP3(void)
  282. {
  283.    CO_AddPOP3();
  284. }
  285. const struct EmulLibEntry Gate_CO_AddPOP3 = { TRAP_LIBNR, 0, (void(*)())Trampoline_CO_AddPOP3 };
  286.  
  287. void CO_DelPOP3(void);
  288. static void  Trampoline_CO_DelPOP3(void)
  289. {
  290.    CO_DelPOP3();
  291. }
  292. const struct EmulLibEntry Gate_CO_DelPOP3 = { TRAP_LIBNR, 0, (void(*)())Trampoline_CO_DelPOP3 };
  293.  
  294. void CO_GetP3Entry(void);
  295. static void  Trampoline_CO_GetP3Entry(void)
  296. {
  297.    CO_GetP3Entry();
  298. }
  299. const struct EmulLibEntry Gate_CO_GetP3Entry = { TRAP_LIBNR, 0, (void(*)())Trampoline_CO_GetP3Entry };
  300.  
  301. void CO_PutP3Entry(void);
  302. static void  Trampoline_CO_PutP3Entry(void)
  303. {
  304.    CO_PutP3Entry();
  305. }
  306. const struct EmulLibEntry Gate_CO_PutP3Entry = { TRAP_LIBNR, 0, (void(*)())Trampoline_CO_PutP3Entry };
  307.  
  308. void CO_GetDefaultPOPFunc(void);
  309. static void  Trampoline_CO_GetDefaultPOPFunc(void)
  310. {
  311.    CO_GetDefaultPOPFunc();
  312. }
  313. const struct EmulLibEntry Gate_CO_GetDefaultPOPFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_CO_GetDefaultPOPFunc };
  314.  
  315. void CO_AddMimeView(void);
  316. static void  Trampoline_CO_AddMimeView(void)
  317. {
  318.    CO_AddMimeView();
  319. }
  320. const struct EmulLibEntry Gate_CO_AddMimeView = { TRAP_LIBNR, 0, (void(*)())Trampoline_CO_AddMimeView };
  321.  
  322. void CO_DelMimeView(void);
  323. static void  Trampoline_CO_DelMimeView(void)
  324. {
  325.    CO_DelMimeView();
  326. }
  327. const struct EmulLibEntry Gate_CO_DelMimeView = { TRAP_LIBNR, 0, (void(*)())Trampoline_CO_DelMimeView };
  328.  
  329. void CO_GetMVEntry(void);
  330. static void  Trampoline_CO_GetMVEntry(void)
  331. {
  332.    CO_GetMVEntry();
  333. }
  334. const struct EmulLibEntry Gate_CO_GetMVEntry = { TRAP_LIBNR, 0, (void(*)())Trampoline_CO_GetMVEntry };
  335.  
  336. void CO_PutMVEntry(void);
  337. static void  Trampoline_CO_PutMVEntry(void)
  338. {
  339.    CO_PutMVEntry();
  340. }
  341. const struct EmulLibEntry Gate_CO_PutMVEntry = { TRAP_LIBNR, 0, (void(*)())Trampoline_CO_PutMVEntry };
  342.  
  343. void CO_GetRXEntry(void);
  344. static void  Trampoline_CO_GetRXEntry(void)
  345. {
  346.    CO_GetRXEntry();
  347. }
  348. const struct EmulLibEntry Gate_CO_GetRXEntry = { TRAP_LIBNR, 0, (void(*)())Trampoline_CO_GetRXEntry };
  349.  
  350. void CO_PutRXEntry(void);
  351. static void  Trampoline_CO_PutRXEntry(void)
  352. {
  353.    CO_PutRXEntry();
  354. }
  355. const struct EmulLibEntry Gate_CO_PutRXEntry = { TRAP_LIBNR, 0, (void(*)())Trampoline_CO_PutRXEntry };
  356.  
  357. void CO_ImportCTypesFunc(void);
  358. static void  Trampoline_CO_ImportCTypesFunc(void)
  359. {
  360.    CO_ImportCTypesFunc();
  361. }
  362. const struct EmulLibEntry Gate_CO_ImportCTypesFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_CO_ImportCTypesFunc };
  363.  
  364. void CO_EditSignatFunc(int *arg);
  365. static void  Trampoline_CO_EditSignatFunc(void)
  366. {
  367.    CO_EditSignatFunc((int *)REG_A1);
  368. }
  369. const struct EmulLibEntry Gate_CO_EditSignatFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_CO_EditSignatFunc };
  370.  
  371. void CO_OpenConfig(void);
  372. static void  Trampoline_CO_OpenConfig(void)
  373. {
  374.    CO_OpenConfig();
  375. }
  376. const struct EmulLibEntry Gate_CO_OpenConfig = { TRAP_LIBNR, 0, (void(*)())Trampoline_CO_OpenConfig };
  377.  
  378. void CO_SaveConfigAs(void);
  379. static void  Trampoline_CO_SaveConfigAs(void)
  380. {
  381.    CO_SaveConfigAs();
  382. }
  383. const struct EmulLibEntry Gate_CO_SaveConfigAs = { TRAP_LIBNR, 0, (void(*)())Trampoline_CO_SaveConfigAs };
  384.  
  385. void CO_Restore(void);
  386. static void  Trampoline_CO_Restore(void)
  387. {
  388.    CO_Restore();
  389. }
  390. const struct EmulLibEntry Gate_CO_Restore = { TRAP_LIBNR, 0, (void(*)())Trampoline_CO_Restore };
  391.  
  392. void CO_LastSaved(void);
  393. static void  Trampoline_CO_LastSaved(void)
  394. {
  395.    CO_LastSaved();
  396. }
  397. const struct EmulLibEntry Gate_CO_LastSaved = { TRAP_LIBNR, 0, (void(*)())Trampoline_CO_LastSaved };
  398.  
  399. void CO_ResetToDefaultFunc(int *arg);
  400. static void  Trampoline_CO_ResetToDefaultFunc(void)
  401. {
  402.    CO_ResetToDefaultFunc((int *)REG_A1);
  403. }
  404. const struct EmulLibEntry Gate_CO_ResetToDefaultFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_CO_ResetToDefaultFunc };
  405.  
  406. void CO_ChangePageFunc(int *arg);
  407. static void  Trampoline_CO_ChangePageFunc(void)
  408. {
  409.    CO_ChangePageFunc((int *)REG_A1);
  410. }
  411. const struct EmulLibEntry Gate_CO_ChangePageFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_CO_ChangePageFunc };
  412.  
  413. void CO_CloseFunc(int *arg);
  414. static void  Trampoline_CO_CloseFunc(void)
  415. {
  416.    CO_CloseFunc((int *)REG_A1);
  417. }
  418. const struct EmulLibEntry Gate_CO_CloseFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_CO_CloseFunc };
  419.  
  420. void CO_OpenFunc(void);
  421. static void  Trampoline_CO_OpenFunc(void)
  422. {
  423.    CO_OpenFunc();
  424. }
  425. const struct EmulLibEntry Gate_CO_OpenFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_CO_OpenFunc };
  426.  
  427. struct Hook;
  428. struct PageList;
  429. long CO_PL_DspFunc(struct Hook *hook, char **array, struct PageList *entry);
  430. static long  Trampoline_CO_PL_DspFunc(void)
  431. {
  432.    return CO_PL_DspFunc((struct Hook *)REG_A0, (char **)REG_A2, (struct PageList *)REG_A1);
  433. }
  434. const struct EmulLibEntry Gate_CO_PL_DspFunc = { TRAP_LIB, 0, (void(*)())Trampoline_CO_PL_DspFunc };
  435.  
  436. void PO_List2TextFunc(Object *list, Object *text);
  437. static void  Trampoline_PO_List2TextFunc(void)
  438. {
  439.    PO_List2TextFunc((Object *)REG_A2, (Object *)REG_A1);
  440. }
  441. const struct EmulLibEntry Gate_PO_List2TextFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_PO_List2TextFunc };
  442.  
  443. struct Hook;
  444. struct TranslationTable;
  445. long CO_LV_TDspFunc(struct Hook *hook, char **array, struct TranslationTable *entry);
  446. static long  Trampoline_CO_LV_TDspFunc(void)
  447. {
  448.    return CO_LV_TDspFunc((struct Hook *)REG_A0, (char **)REG_A2, (struct TranslationTable *)REG_A1);
  449. }
  450. const struct EmulLibEntry Gate_CO_LV_TDspFunc = { TRAP_LIB, 0, (void(*)())Trampoline_CO_LV_TDspFunc };
  451.  
  452. struct TranslationTable;
  453. struct TranslationTable * CO_LV_TConFunc(struct TranslationTable *tt);
  454. static struct TranslationTable *  Trampoline_CO_LV_TConFunc(void)
  455. {
  456.    return CO_LV_TConFunc((struct TranslationTable *)REG_A1);
  457. }
  458. const struct EmulLibEntry Gate_CO_LV_TConFunc = { TRAP_LIB, 0, (void(*)())Trampoline_CO_LV_TConFunc };
  459.  
  460. struct Hook;
  461. long CO_LV_RxDspFunc(struct Hook *hook, char **array, int num);
  462. static long  Trampoline_CO_LV_RxDspFunc(void)
  463. {
  464.    return CO_LV_RxDspFunc((struct Hook *)REG_A0, (char **)REG_A2, (int)REG_A1);
  465. }
  466. const struct EmulLibEntry Gate_CO_LV_RxDspFunc = { TRAP_LIB, 0, (void(*)())Trampoline_CO_LV_RxDspFunc };
  467.  
  468. void PO_HandleXPKFunc(APTR text, APTR pop);
  469. static void  Trampoline_PO_HandleXPKFunc(void)
  470. {
  471.    PO_HandleXPKFunc((APTR)REG_A1, (APTR)REG_A2);
  472. }
  473. const struct EmulLibEntry Gate_PO_HandleXPKFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_PO_HandleXPKFunc };
  474.  
  475. void PO_HandleTrans(APTR string, APTR pop);
  476. static void  Trampoline_PO_HandleTrans(void)
  477. {
  478.    PO_HandleTrans((APTR)REG_A1, (APTR)REG_A2);
  479. }
  480. const struct EmulLibEntry Gate_PO_HandleTrans = { TRAP_LIBNR, 0, (void(*)())Trampoline_PO_HandleTrans };
  481.  
  482. void PO_HandleVar(APTR string, APTR pop);
  483. static void  Trampoline_PO_HandleVar(void)
  484. {
  485.    PO_HandleVar((APTR)REG_A1, (APTR)REG_A2);
  486. }
  487. const struct EmulLibEntry Gate_PO_HandleVar = { TRAP_LIBNR, 0, (void(*)())Trampoline_PO_HandleVar };
  488.  
  489. void CO_PlaySoundFunc(int *arg);
  490. static void  Trampoline_CO_PlaySoundFunc(void)
  491. {
  492.    CO_PlaySoundFunc((int *)REG_A1);
  493. }
  494. const struct EmulLibEntry Gate_CO_PlaySoundFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_CO_PlaySoundFunc };
  495.  
  496. void DI_CloseFunc(void);
  497. static void  Trampoline_DI_CloseFunc(void)
  498. {
  499.    DI_CloseFunc();
  500. }
  501. const struct EmulLibEntry Gate_DI_CloseFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_DI_CloseFunc };
  502.  
  503. void DI_PasteFunc(void);
  504. static void  Trampoline_DI_PasteFunc(void)
  505. {
  506.    DI_PasteFunc();
  507. }
  508. const struct EmulLibEntry Gate_DI_PasteFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_DI_PasteFunc };
  509.  
  510. void DI_DeleteFunc(void);
  511. static void  Trampoline_DI_DeleteFunc(void)
  512. {
  513.    DI_DeleteFunc();
  514. }
  515. const struct EmulLibEntry Gate_DI_DeleteFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_DI_DeleteFunc };
  516.  
  517. void DI_DisplayFunc(void);
  518. static void  Trampoline_DI_DisplayFunc(void)
  519. {
  520.    DI_DisplayFunc();
  521. }
  522. const struct EmulLibEntry Gate_DI_DisplayFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_DI_DisplayFunc };
  523.  
  524. void DI_ModifyFunc(int *arg);
  525. static void  Trampoline_DI_ModifyFunc(void)
  526. {
  527.    DI_ModifyFunc((int *)REG_A1);
  528. }
  529. const struct EmulLibEntry Gate_DI_ModifyFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_DI_ModifyFunc };
  530.  
  531. void DI_OpenFunc(int *arg);
  532. static void  Trampoline_DI_OpenFunc(void)
  533. {
  534.    DI_OpenFunc((int *)REG_A1);
  535. }
  536. const struct EmulLibEntry Gate_DI_OpenFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_DI_OpenFunc };
  537.  
  538. struct Dict;
  539. struct Dict * DI_LV_ConFunc(struct Dict *dict);
  540. static struct Dict *  Trampoline_DI_LV_ConFunc(void)
  541. {
  542.    return DI_LV_ConFunc((struct Dict *)REG_A1);
  543. }
  544. const struct EmulLibEntry Gate_DI_LV_ConFunc = { TRAP_LIB, 0, (void(*)())Trampoline_DI_LV_ConFunc };
  545.  
  546. struct Dict;
  547. long DI_LV_DesFunc(struct Dict *entry);
  548. static long  Trampoline_DI_LV_DesFunc(void)
  549. {
  550.    return DI_LV_DesFunc((struct Dict *)REG_A1);
  551. }
  552. const struct EmulLibEntry Gate_DI_LV_DesFunc = { TRAP_LIB, 0, (void(*)())Trampoline_DI_LV_DesFunc };
  553.  
  554. void EA_GetEntry(int *arg);
  555. static void  Trampoline_EA_GetEntry(void)
  556. {
  557.    EA_GetEntry((int *)REG_A1);
  558. }
  559. const struct EmulLibEntry Gate_EA_GetEntry = { TRAP_LIBNR, 0, (void(*)())Trampoline_EA_GetEntry };
  560.  
  561. void EA_PutEntry(int *arg);
  562. static void  Trampoline_EA_PutEntry(void)
  563. {
  564.    EA_PutEntry((int *)REG_A1);
  565. }
  566. const struct EmulLibEntry Gate_EA_PutEntry = { TRAP_LIBNR, 0, (void(*)())Trampoline_EA_PutEntry };
  567.  
  568. void EA_Okay(int *arg);
  569. static void  Trampoline_EA_Okay(void)
  570. {
  571.    EA_Okay((int *)REG_A1);
  572. }
  573. const struct EmulLibEntry Gate_EA_Okay = { TRAP_LIBNR, 0, (void(*)())Trampoline_EA_Okay };
  574.  
  575. void EA_AddFunc(int *arg);
  576. static void  Trampoline_EA_AddFunc(void)
  577. {
  578.    EA_AddFunc((int *)REG_A1);
  579. }
  580. const struct EmulLibEntry Gate_EA_AddFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_EA_AddFunc };
  581.  
  582. void EA_SelectPhotoFunc(int *arg);
  583. static void  Trampoline_EA_SelectPhotoFunc(void)
  584. {
  585.    EA_SelectPhotoFunc((int *)REG_A1);
  586. }
  587. const struct EmulLibEntry Gate_EA_SelectPhotoFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_EA_SelectPhotoFunc };
  588.  
  589. void EA_DownloadPhotoFunc(int *arg);
  590. static void  Trampoline_EA_DownloadPhotoFunc(void)
  591. {
  592.    EA_DownloadPhotoFunc((int *)REG_A1);
  593. }
  594. const struct EmulLibEntry Gate_EA_DownloadPhotoFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_EA_DownloadPhotoFunc };
  595.  
  596. void EA_HomepageFunc(int *arg);
  597. static void  Trampoline_EA_HomepageFunc(void)
  598. {
  599.    EA_HomepageFunc((int *)REG_A1);
  600. }
  601. const struct EmulLibEntry Gate_EA_HomepageFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_EA_HomepageFunc };
  602.  
  603. void EA_CloseFunc(int *arg);
  604. static void  Trampoline_EA_CloseFunc(void)
  605. {
  606.    EA_CloseFunc((int *)REG_A1);
  607. }
  608. const struct EmulLibEntry Gate_EA_CloseFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_EA_CloseFunc };
  609.  
  610. void ER_SelectFunc(int *arg);
  611. static void  Trampoline_ER_SelectFunc(void)
  612. {
  613.    ER_SelectFunc((int *)REG_A1);
  614. }
  615. const struct EmulLibEntry Gate_ER_SelectFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_ER_SelectFunc };
  616.  
  617. void ER_CloseFunc(int *arg);
  618. static void  Trampoline_ER_CloseFunc(void)
  619. {
  620.    ER_CloseFunc((int *)REG_A1);
  621. }
  622. const struct EmulLibEntry Gate_ER_CloseFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_ER_CloseFunc };
  623.  
  624. void FI_SearchFunc(void);
  625. static void  Trampoline_FI_SearchFunc(void)
  626. {
  627.    FI_SearchFunc();
  628. }
  629. const struct EmulLibEntry Gate_FI_SearchFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_FI_SearchFunc };
  630.  
  631. void FI_ToRuleFunc(void);
  632. static void  Trampoline_FI_ToRuleFunc(void)
  633. {
  634.    FI_ToRuleFunc();
  635. }
  636. const struct EmulLibEntry Gate_FI_ToRuleFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_FI_ToRuleFunc };
  637.  
  638. void FI_Open(void);
  639. static void  Trampoline_FI_Open(void)
  640. {
  641.    FI_Open();
  642. }
  643. const struct EmulLibEntry Gate_FI_Open = { TRAP_LIBNR, 0, (void(*)())Trampoline_FI_Open };
  644.  
  645. void FI_SearchOptFunc(ULONG *arg);
  646. static void  Trampoline_FI_SearchOptFunc(void)
  647. {
  648.    FI_SearchOptFunc((ULONG *)REG_A1);
  649. }
  650. const struct EmulLibEntry Gate_FI_SearchOptFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_FI_SearchOptFunc };
  651.  
  652. void FI_EditFileFunc(int *arg);
  653. static void  Trampoline_FI_EditFileFunc(void)
  654. {
  655.    FI_EditFileFunc((int *)REG_A1);
  656. }
  657. const struct EmulLibEntry Gate_FI_EditFileFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_FI_EditFileFunc };
  658.  
  659. void FI_SwitchFunc(void);
  660. static void  Trampoline_FI_SwitchFunc(void)
  661. {
  662.    FI_SwitchFunc();
  663. }
  664. const struct EmulLibEntry Gate_FI_SwitchFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_FI_SwitchFunc };
  665.  
  666. void FI_ReadFunc(void);
  667. static void  Trampoline_FI_ReadFunc(void)
  668. {
  669.    FI_ReadFunc();
  670. }
  671. const struct EmulLibEntry Gate_FI_ReadFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_FI_ReadFunc };
  672.  
  673. void FI_SelectFunc(void);
  674. static void  Trampoline_FI_SelectFunc(void)
  675. {
  676.    FI_SelectFunc();
  677. }
  678. const struct EmulLibEntry Gate_FI_SelectFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_FI_SelectFunc };
  679.  
  680. void FI_Close(void);
  681. static void  Trampoline_FI_Close(void)
  682. {
  683.    FI_Close();
  684. }
  685. const struct EmulLibEntry Gate_FI_Close = { TRAP_LIBNR, 0, (void(*)())Trampoline_FI_Close };
  686.  
  687. long FI_PO_InitRuleListFunc(Object *pop);
  688. static long  Trampoline_FI_PO_InitRuleListFunc(void)
  689. {
  690.    return FI_PO_InitRuleListFunc((Object *)REG_A2);
  691. }
  692. const struct EmulLibEntry Gate_FI_PO_InitRuleListFunc = { TRAP_LIB, 0, (void(*)())Trampoline_FI_PO_InitRuleListFunc };
  693.  
  694. void FI_PO_FromRuleFunc(Object *pop);
  695. static void  Trampoline_FI_PO_FromRuleFunc(void)
  696. {
  697.    FI_PO_FromRuleFunc((Object *)REG_A2);
  698. }
  699. const struct EmulLibEntry Gate_FI_PO_FromRuleFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_FI_PO_FromRuleFunc };
  700.  
  701. void FO_NewSeparatorFunc(void);
  702. static void  Trampoline_FO_NewSeparatorFunc(void)
  703. {
  704.    FO_NewSeparatorFunc();
  705. }
  706. const struct EmulLibEntry Gate_FO_NewSeparatorFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_FO_NewSeparatorFunc };
  707.  
  708. void FO_NewFolderFunc(void);
  709. static void  Trampoline_FO_NewFolderFunc(void)
  710. {
  711.    FO_NewFolderFunc();
  712. }
  713. const struct EmulLibEntry Gate_FO_NewFolderFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_FO_NewFolderFunc };
  714.  
  715. void FO_EditFolderFunc(void);
  716. static void  Trampoline_FO_EditFolderFunc(void)
  717. {
  718.    FO_EditFolderFunc();
  719. }
  720. const struct EmulLibEntry Gate_FO_EditFolderFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_FO_EditFolderFunc };
  721.  
  722. void FO_DeleteFolderFunc(void);
  723. static void  Trampoline_FO_DeleteFolderFunc(void)
  724. {
  725.    FO_DeleteFolderFunc();
  726. }
  727. const struct EmulLibEntry Gate_FO_DeleteFolderFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_FO_DeleteFolderFunc };
  728.  
  729. void FO_MoveFunc(void);
  730. static void  Trampoline_FO_MoveFunc(void)
  731. {
  732.    FO_MoveFunc();
  733. }
  734. const struct EmulLibEntry Gate_FO_MoveFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_FO_MoveFunc };
  735.  
  736. void FO_CloseFunc(void);
  737. static void  Trampoline_FO_CloseFunc(void)
  738. {
  739.    FO_CloseFunc();
  740. }
  741. const struct EmulLibEntry Gate_FO_CloseFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_FO_CloseFunc };
  742.  
  743. void FO_SaveFunc(void);
  744. static void  Trampoline_FO_SaveFunc(void)
  745. {
  746.    FO_SaveFunc();
  747. }
  748. const struct EmulLibEntry Gate_FO_SaveFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_FO_SaveFunc };
  749.  
  750. void FO_SetOrderFunc(int *arg);
  751. static void  Trampoline_FO_SetOrderFunc(void)
  752. {
  753.    FO_SetOrderFunc((int *)REG_A1);
  754. }
  755. const struct EmulLibEntry Gate_FO_SetOrderFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_FO_SetOrderFunc };
  756.  
  757. void MA_ChangeSelectedFunc(void);
  758. static void  Trampoline_MA_ChangeSelectedFunc(void)
  759. {
  760.    MA_ChangeSelectedFunc();
  761. }
  762. const struct EmulLibEntry Gate_MA_ChangeSelectedFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_MA_ChangeSelectedFunc };
  763.  
  764. void MA_SetMessageInfoFunc(void);
  765. static void  Trampoline_MA_SetMessageInfoFunc(void)
  766. {
  767.    MA_SetMessageInfoFunc();
  768. }
  769. const struct EmulLibEntry Gate_MA_SetMessageInfoFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_MA_SetMessageInfoFunc };
  770.  
  771. void MA_SetFolderInfoFunc(void);
  772. static void  Trampoline_MA_SetFolderInfoFunc(void)
  773. {
  774.    MA_SetFolderInfoFunc();
  775. }
  776. const struct EmulLibEntry Gate_MA_SetFolderInfoFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_MA_SetFolderInfoFunc };
  777.  
  778. void MA_ReadMessage(int *arg);
  779. static void  Trampoline_MA_ReadMessage(void)
  780. {
  781.    MA_ReadMessage((int *)REG_A1);
  782. }
  783. const struct EmulLibEntry Gate_MA_ReadMessage = { TRAP_LIBNR, 0, (void(*)())Trampoline_MA_ReadMessage };
  784.  
  785. void MA_RemoveAttachFunc(void);
  786. static void  Trampoline_MA_RemoveAttachFunc(void)
  787. {
  788.    MA_RemoveAttachFunc();
  789. }
  790. const struct EmulLibEntry Gate_MA_RemoveAttachFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_MA_RemoveAttachFunc };
  791.  
  792. void MA_SaveAttachFunc(void);
  793. static void  Trampoline_MA_SaveAttachFunc(void)
  794. {
  795.    MA_SaveAttachFunc();
  796. }
  797. const struct EmulLibEntry Gate_MA_SaveAttachFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_MA_SaveAttachFunc };
  798.  
  799. void MA_SavePrintFunc(int *arg);
  800. static void  Trampoline_MA_SavePrintFunc(void)
  801. {
  802.    MA_SavePrintFunc((int *)REG_A1);
  803. }
  804. const struct EmulLibEntry Gate_MA_SavePrintFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_MA_SavePrintFunc };
  805.  
  806. void MA_NewMessageFunc(int *arg);
  807. static void  Trampoline_MA_NewMessageFunc(void)
  808. {
  809.    MA_NewMessageFunc((int *)REG_A1);
  810. }
  811. const struct EmulLibEntry Gate_MA_NewMessageFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_MA_NewMessageFunc };
  812.  
  813. void MA_DeleteMessageFunc(int *arg);
  814. static void  Trampoline_MA_DeleteMessageFunc(void)
  815. {
  816.    MA_DeleteMessageFunc((int *)REG_A1);
  817. }
  818. const struct EmulLibEntry Gate_MA_DeleteMessageFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_MA_DeleteMessageFunc };
  819.  
  820. void MA_DelKeyFunc(int *arg);
  821. static void  Trampoline_MA_DelKeyFunc(void)
  822. {
  823.    MA_DelKeyFunc((int *)REG_A1);
  824. }
  825. const struct EmulLibEntry Gate_MA_DelKeyFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_MA_DelKeyFunc };
  826.  
  827. void MA_GetAddressFunc(void);
  828. static void  Trampoline_MA_GetAddressFunc(void)
  829. {
  830.    MA_GetAddressFunc();
  831. }
  832. const struct EmulLibEntry Gate_MA_GetAddressFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_MA_GetAddressFunc };
  833.  
  834. void MA_PopNowFunc(int *arg);
  835. static void  Trampoline_MA_PopNowFunc(void)
  836. {
  837.    MA_PopNowFunc((int *)REG_A1);
  838. }
  839. const struct EmulLibEntry Gate_MA_PopNowFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_MA_PopNowFunc };
  840.  
  841. void MA_ApplyRulesFunc(int *arg);
  842. static void  Trampoline_MA_ApplyRulesFunc(void)
  843. {
  844.    MA_ApplyRulesFunc((int *)REG_A1);
  845. }
  846. const struct EmulLibEntry Gate_MA_ApplyRulesFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_MA_ApplyRulesFunc };
  847.  
  848. void MA_SendFunc(int *arg);
  849. static void  Trampoline_MA_SendFunc(void)
  850. {
  851.    MA_SendFunc((int *)REG_A1);
  852. }
  853. const struct EmulLibEntry Gate_MA_SendFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_MA_SendFunc };
  854.  
  855. void MA_SetStatusToFunc(int *arg);
  856. static void  Trampoline_MA_SetStatusToFunc(void)
  857. {
  858.    MA_SetStatusToFunc((int *)REG_A1);
  859. }
  860. const struct EmulLibEntry Gate_MA_SetStatusToFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_MA_SetStatusToFunc };
  861.  
  862. void MA_SelectAllFunc(void);
  863. static void  Trampoline_MA_SelectAllFunc(void)
  864. {
  865.    MA_SelectAllFunc();
  866. }
  867. const struct EmulLibEntry Gate_MA_SelectAllFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_MA_SelectAllFunc };
  868.  
  869. void MA_DeleteOldFunc(void);
  870. static void  Trampoline_MA_DeleteOldFunc(void)
  871. {
  872.    MA_DeleteOldFunc();
  873. }
  874. const struct EmulLibEntry Gate_MA_DeleteOldFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_MA_DeleteOldFunc };
  875.  
  876. void MA_DeleteDeletedFunc(void);
  877. static void  Trampoline_MA_DeleteDeletedFunc(void)
  878. {
  879.    MA_DeleteDeletedFunc();
  880. }
  881. const struct EmulLibEntry Gate_MA_DeleteDeletedFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_MA_DeleteDeletedFunc };
  882.  
  883. void MA_RescanIndexFunc(void);
  884. static void  Trampoline_MA_RescanIndexFunc(void)
  885. {
  886.    MA_RescanIndexFunc();
  887. }
  888. const struct EmulLibEntry Gate_MA_RescanIndexFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_MA_RescanIndexFunc };
  889.  
  890. void MA_ExportMessagesFunc(int *arg);
  891. static void  Trampoline_MA_ExportMessagesFunc(void)
  892. {
  893.    MA_ExportMessagesFunc((int *)REG_A1);
  894. }
  895. const struct EmulLibEntry Gate_MA_ExportMessagesFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_MA_ExportMessagesFunc };
  896.  
  897. void MA_ImportMessagesFunc(void);
  898. static void  Trampoline_MA_ImportMessagesFunc(void)
  899. {
  900.    MA_ImportMessagesFunc();
  901. }
  902. const struct EmulLibEntry Gate_MA_ImportMessagesFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_MA_ImportMessagesFunc };
  903.  
  904. void MA_MoveMessageFunc(void);
  905. static void  Trampoline_MA_MoveMessageFunc(void)
  906. {
  907.    MA_MoveMessageFunc();
  908. }
  909. const struct EmulLibEntry Gate_MA_MoveMessageFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_MA_MoveMessageFunc };
  910.  
  911. void MA_CopyMessageFunc(void);
  912. static void  Trampoline_MA_CopyMessageFunc(void)
  913. {
  914.    MA_CopyMessageFunc();
  915. }
  916. const struct EmulLibEntry Gate_MA_CopyMessageFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_MA_CopyMessageFunc };
  917.  
  918. void MA_ChangeSubjectFunc(void);
  919. static void  Trampoline_MA_ChangeSubjectFunc(void)
  920. {
  921.    MA_ChangeSubjectFunc();
  922. }
  923. const struct EmulLibEntry Gate_MA_ChangeSubjectFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_MA_ChangeSubjectFunc };
  924.  
  925. void MA_AboutMUIFunc(void);
  926. static void  Trampoline_MA_AboutMUIFunc(void)
  927. {
  928.    MA_AboutMUIFunc();
  929. }
  930. const struct EmulLibEntry Gate_MA_AboutMUIFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_MA_AboutMUIFunc };
  931.  
  932. void MA_CheckVersionFunc(void);
  933. static void  Trampoline_MA_CheckVersionFunc(void)
  934. {
  935.    MA_CheckVersionFunc();
  936. }
  937. const struct EmulLibEntry Gate_MA_CheckVersionFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_MA_CheckVersionFunc };
  938.  
  939. void MA_ShowErrorsFunc(void);
  940. static void  Trampoline_MA_ShowErrorsFunc(void)
  941. {
  942.    MA_ShowErrorsFunc();
  943. }
  944. const struct EmulLibEntry Gate_MA_ShowErrorsFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_MA_ShowErrorsFunc };
  945.  
  946. void MA_CallRexxFunc(int *arg);
  947. static void  Trampoline_MA_CallRexxFunc(void)
  948. {
  949.    MA_CallRexxFunc((int *)REG_A1);
  950. }
  951. const struct EmulLibEntry Gate_MA_CallRexxFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_MA_CallRexxFunc };
  952.  
  953. void PO_Window(Object *pop, Object *win);
  954. static void  Trampoline_PO_Window(void)
  955. {
  956.    PO_Window((Object *)REG_A2, (Object *)REG_A1);
  957. }
  958. const struct EmulLibEntry Gate_PO_Window = { TRAP_LIBNR, 0, (void(*)())Trampoline_PO_Window };
  959.  
  960. struct Folder;
  961. struct Folder * MA_LV_FConFunc(struct Folder *fo);
  962. static struct Folder *  Trampoline_MA_LV_FConFunc(void)
  963. {
  964.    return MA_LV_FConFunc((struct Folder *)REG_A1);
  965. }
  966. const struct EmulLibEntry Gate_MA_LV_FConFunc = { TRAP_LIB, 0, (void(*)())Trampoline_MA_LV_FConFunc };
  967.  
  968. struct Hook;
  969. struct Mail;
  970. long MA_LV_DspFunc(struct Hook *hook, char **array, struct Mail *entry);
  971. static long  Trampoline_MA_LV_DspFunc(void)
  972. {
  973.    return MA_LV_DspFunc((struct Hook *)REG_A0, (char **)REG_A2, (struct Mail *)REG_A1);
  974. }
  975. const struct EmulLibEntry Gate_MA_LV_DspFunc = { TRAP_LIB, 0, (void(*)())Trampoline_MA_LV_DspFunc };
  976.  
  977. struct NList_CompareMessage;
  978. long MA_LV_Cmp2Func(struct NList_CompareMessage *ncm, Object *obj);
  979. static long  Trampoline_MA_LV_Cmp2Func(void)
  980. {
  981.    return MA_LV_Cmp2Func((struct NList_CompareMessage *)REG_A1, (Object *)REG_A2);
  982. }
  983. const struct EmulLibEntry Gate_MA_LV_Cmp2Func = { TRAP_LIB, 0, (void(*)())Trampoline_MA_LV_Cmp2Func };
  984.  
  985. struct NList_CompareMessage;
  986. long MA_LV_FCmp2Func(struct NList_CompareMessage *ncm, Object *obj);
  987. static long  Trampoline_MA_LV_FCmp2Func(void)
  988. {
  989.    return MA_LV_FCmp2Func((struct NList_CompareMessage *)REG_A1, (Object *)REG_A2);
  990. }
  991. const struct EmulLibEntry Gate_MA_LV_FCmp2Func = { TRAP_LIB, 0, (void(*)())Trampoline_MA_LV_FCmp2Func };
  992.  
  993. void MA_FlushIndexFunc(void);
  994. static void  Trampoline_MA_FlushIndexFunc(void)
  995. {
  996.    MA_FlushIndexFunc();
  997. }
  998. const struct EmulLibEntry Gate_MA_FlushIndexFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_MA_FlushIndexFunc };
  999.  
  1000. void MA_ChangeFolderFunc(void);
  1001. static void  Trampoline_MA_ChangeFolderFunc(void)
  1002. {
  1003.    MA_ChangeFolderFunc();
  1004. }
  1005. const struct EmulLibEntry Gate_MA_ChangeFolderFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_MA_ChangeFolderFunc };
  1006.  
  1007. long PO_InitFolderList(Object *pop);
  1008. static long  Trampoline_PO_InitFolderList(void)
  1009. {
  1010.    return PO_InitFolderList((Object *)REG_A2);
  1011. }
  1012. const struct EmulLibEntry Gate_PO_InitFolderList = { TRAP_LIB, 0, (void(*)())Trampoline_PO_InitFolderList };
  1013.  
  1014. struct Folder;
  1015. long MA_LV_FDspFunc(char **array, struct Folder *entry);
  1016. static long  Trampoline_MA_LV_FDspFunc(void)
  1017. {
  1018.    return MA_LV_FDspFunc((char **)REG_A2, (struct Folder *)REG_A1);
  1019. }
  1020. const struct EmulLibEntry Gate_MA_LV_FDspFunc = { TRAP_LIB, 0, (void(*)())Trampoline_MA_LV_FDspFunc };
  1021.  
  1022. void RE_Follow(int *arg);
  1023. static void  Trampoline_RE_Follow(void)
  1024. {
  1025.    RE_Follow((int *)REG_A1);
  1026. }
  1027. const struct EmulLibEntry Gate_RE_Follow = { TRAP_LIBNR, 0, (void(*)())Trampoline_RE_Follow };
  1028.  
  1029. void RE_PrevNext(int *arg);
  1030. static void  Trampoline_RE_PrevNext(void)
  1031. {
  1032.    RE_PrevNext((int *)REG_A1);
  1033. }
  1034. const struct EmulLibEntry Gate_RE_PrevNext = { TRAP_LIBNR, 0, (void(*)())Trampoline_RE_PrevNext };
  1035.  
  1036. void RE_PrevNextPageFunc(int *arg);
  1037. static void  Trampoline_RE_PrevNextPageFunc(void)
  1038. {
  1039.    RE_PrevNextPageFunc((int *)REG_A1);
  1040. }
  1041. const struct EmulLibEntry Gate_RE_PrevNextPageFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_RE_PrevNextPageFunc };
  1042.  
  1043. void RE_MoveFunc(int *arg);
  1044. static void  Trampoline_RE_MoveFunc(void)
  1045. {
  1046.    RE_MoveFunc((int *)REG_A1);
  1047. }
  1048. const struct EmulLibEntry Gate_RE_MoveFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_RE_MoveFunc };
  1049.  
  1050. void RE_CopyFunc(int *arg);
  1051. static void  Trampoline_RE_CopyFunc(void)
  1052. {
  1053.    RE_CopyFunc((int *)REG_A1);
  1054. }
  1055. const struct EmulLibEntry Gate_RE_CopyFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_RE_CopyFunc };
  1056.  
  1057. void RE_DeleteFunc(int *arg);
  1058. static void  Trampoline_RE_DeleteFunc(void)
  1059. {
  1060.    RE_DeleteFunc((int *)REG_A1);
  1061. }
  1062. const struct EmulLibEntry Gate_RE_DeleteFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_RE_DeleteFunc };
  1063.  
  1064. void RE_PrintFunc(int *arg);
  1065. static void  Trampoline_RE_PrintFunc(void)
  1066. {
  1067.    RE_PrintFunc((int *)REG_A1);
  1068. }
  1069. const struct EmulLibEntry Gate_RE_PrintFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_RE_PrintFunc };
  1070.  
  1071. void RE_SaveFunc(int *arg);
  1072. static void  Trampoline_RE_SaveFunc(void)
  1073. {
  1074.    RE_SaveFunc((int *)REG_A1);
  1075. }
  1076. const struct EmulLibEntry Gate_RE_SaveFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_RE_SaveFunc };
  1077.  
  1078. void RE_DisplayFunc(int *arg);
  1079. static void  Trampoline_RE_DisplayFunc(void)
  1080. {
  1081.    RE_DisplayFunc((int *)REG_A1);
  1082. }
  1083. const struct EmulLibEntry Gate_RE_DisplayFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_RE_DisplayFunc };
  1084.  
  1085. void RE_SaveAllFunc(int *arg);
  1086. static void  Trampoline_RE_SaveAllFunc(void)
  1087. {
  1088.    RE_SaveAllFunc((int *)REG_A1);
  1089. }
  1090. const struct EmulLibEntry Gate_RE_SaveAllFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_RE_SaveAllFunc };
  1091.  
  1092. void RE_RemoveAttachFunc(int *arg);
  1093. static void  Trampoline_RE_RemoveAttachFunc(void)
  1094. {
  1095.    RE_RemoveAttachFunc((int *)REG_A1);
  1096. }
  1097. const struct EmulLibEntry Gate_RE_RemoveAttachFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_RE_RemoveAttachFunc };
  1098.  
  1099. void RE_NewFunc(int *arg);
  1100. static void  Trampoline_RE_NewFunc(void)
  1101. {
  1102.    RE_NewFunc((int *)REG_A1);
  1103. }
  1104. const struct EmulLibEntry Gate_RE_NewFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_RE_NewFunc };
  1105.  
  1106. void RE_GetAddressFunc(int *arg);
  1107. static void  Trampoline_RE_GetAddressFunc(void)
  1108. {
  1109.    RE_GetAddressFunc((int *)REG_A1);
  1110. }
  1111. const struct EmulLibEntry Gate_RE_GetAddressFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_RE_GetAddressFunc };
  1112.  
  1113. void RE_SetUnreadFunc(int *arg);
  1114. static void  Trampoline_RE_SetUnreadFunc(void)
  1115. {
  1116.    RE_SetUnreadFunc((int *)REG_A1);
  1117. }
  1118. const struct EmulLibEntry Gate_RE_SetUnreadFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_RE_SetUnreadFunc };
  1119.  
  1120. void RE_ChangeSubjectFunc(int *arg);
  1121. static void  Trampoline_RE_ChangeSubjectFunc(void)
  1122. {
  1123.    RE_ChangeSubjectFunc((int *)REG_A1);
  1124. }
  1125. const struct EmulLibEntry Gate_RE_ChangeSubjectFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_RE_ChangeSubjectFunc };
  1126.  
  1127. void RE_ExtractKeyFunc(int *arg);
  1128. static void  Trampoline_RE_ExtractKeyFunc(void)
  1129. {
  1130.    RE_ExtractKeyFunc((int *)REG_A1);
  1131. }
  1132. const struct EmulLibEntry Gate_RE_ExtractKeyFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_RE_ExtractKeyFunc };
  1133.  
  1134. void RE_CheckSignatureFunc(int *arg);
  1135. static void  Trampoline_RE_CheckSignatureFunc(void)
  1136. {
  1137.    RE_CheckSignatureFunc((int *)REG_A1);
  1138. }
  1139. const struct EmulLibEntry Gate_RE_CheckSignatureFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_RE_CheckSignatureFunc };
  1140.  
  1141. void RE_SaveDecryptedFunc(int *arg);
  1142. static void  Trampoline_RE_SaveDecryptedFunc(void)
  1143. {
  1144.    RE_SaveDecryptedFunc((int *)REG_A1);
  1145. }
  1146. const struct EmulLibEntry Gate_RE_SaveDecryptedFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_RE_SaveDecryptedFunc };
  1147.  
  1148. struct ClickMessage;
  1149. BOOL RE_DoubleClickFunc(struct ClickMessage *clickmsg, APTR obj);
  1150. static BOOL  Trampoline_RE_DoubleClickFunc(void)
  1151. {
  1152.    return RE_DoubleClickFunc((struct ClickMessage *)REG_A1, (APTR)REG_A2);
  1153. }
  1154. const struct EmulLibEntry Gate_RE_DoubleClickFunc = { TRAP_LIB, 0, (void(*)())Trampoline_RE_DoubleClickFunc };
  1155.  
  1156. void RE_ShowEnvFunc(int *arg);
  1157. static void  Trampoline_RE_ShowEnvFunc(void)
  1158. {
  1159.    RE_ShowEnvFunc((int *)REG_A1);
  1160. }
  1161. const struct EmulLibEntry Gate_RE_ShowEnvFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_RE_ShowEnvFunc };
  1162.  
  1163. struct Part;
  1164. long RE_LV_AttachDspFunc(char **array, struct Part *entry);
  1165. static long  Trampoline_RE_LV_AttachDspFunc(void)
  1166. {
  1167.    return RE_LV_AttachDspFunc((char **)REG_A2, (struct Part *)REG_A1);
  1168. }
  1169. const struct EmulLibEntry Gate_RE_LV_AttachDspFunc = { TRAP_LIB, 0, (void(*)())Trampoline_RE_LV_AttachDspFunc };
  1170.  
  1171. void RE_CloseFunc(int *arg);
  1172. static void  Trampoline_RE_CloseFunc(void)
  1173. {
  1174.    RE_CloseFunc((int *)REG_A1);
  1175. }
  1176. const struct EmulLibEntry Gate_RE_CloseFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_RE_CloseFunc };
  1177.  
  1178. long RE_LV_HDspFunc(char **array, char *entry);
  1179. static long  Trampoline_RE_LV_HDspFunc(void)
  1180. {
  1181.    return RE_LV_HDspFunc((char **)REG_A2, (char *)REG_A1);
  1182. }
  1183. const struct EmulLibEntry Gate_RE_LV_HDspFunc = { TRAP_LIB, 0, (void(*)())Trampoline_RE_LV_HDspFunc };
  1184.  
  1185. void TR_ChangeStatusFunc(int *arg);
  1186. static void  Trampoline_TR_ChangeStatusFunc(void)
  1187. {
  1188.    TR_ChangeStatusFunc((int *)REG_A1);
  1189. }
  1190. const struct EmulLibEntry Gate_TR_ChangeStatusFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_TR_ChangeStatusFunc };
  1191.  
  1192. void TR_AbortIMPORTFunc(void);
  1193. static void  Trampoline_TR_AbortIMPORTFunc(void)
  1194. {
  1195.    TR_AbortIMPORTFunc();
  1196. }
  1197. const struct EmulLibEntry Gate_TR_AbortIMPORTFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_TR_AbortIMPORTFunc };
  1198.  
  1199. void TR_ProcessIMPORTFunc(void);
  1200. static void  Trampoline_TR_ProcessIMPORTFunc(void)
  1201. {
  1202.    TR_ProcessIMPORTFunc();
  1203. }
  1204. const struct EmulLibEntry Gate_TR_ProcessIMPORTFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_TR_ProcessIMPORTFunc };
  1205.  
  1206. void TR_AbortGETFunc(void);
  1207. static void  Trampoline_TR_AbortGETFunc(void)
  1208. {
  1209.    TR_AbortGETFunc();
  1210. }
  1211. const struct EmulLibEntry Gate_TR_AbortGETFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_TR_AbortGETFunc };
  1212.  
  1213. void TR_ProcessGETFunc(void);
  1214. static void  Trampoline_TR_ProcessGETFunc(void)
  1215. {
  1216.    TR_ProcessGETFunc();
  1217. }
  1218. const struct EmulLibEntry Gate_TR_ProcessGETFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_TR_ProcessGETFunc };
  1219.  
  1220. void TR_GetMessageInfoFunc(void);
  1221. static void  Trampoline_TR_GetMessageInfoFunc(void)
  1222. {
  1223.    TR_GetMessageInfoFunc();
  1224. }
  1225. const struct EmulLibEntry Gate_TR_GetMessageInfoFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_TR_GetMessageInfoFunc };
  1226.  
  1227. void TR_PauseFunc(int *arg);
  1228. static void  Trampoline_TR_PauseFunc(void)
  1229. {
  1230.    TR_PauseFunc((int *)REG_A1);
  1231. }
  1232. const struct EmulLibEntry Gate_TR_PauseFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_TR_PauseFunc };
  1233.  
  1234. struct Hook;
  1235. struct Mail;
  1236. long TR_LV_DspFunc(struct Hook *hook, char **array, struct Mail *entry);
  1237. static long  Trampoline_TR_LV_DspFunc(void)
  1238. {
  1239.    return TR_LV_DspFunc((struct Hook *)REG_A0, (char **)REG_A2, (struct Mail *)REG_A1);
  1240. }
  1241. const struct EmulLibEntry Gate_TR_LV_DspFunc = { TRAP_LIB, 0, (void(*)())Trampoline_TR_LV_DspFunc };
  1242.  
  1243. void US_DelFunc(void);
  1244. static void  Trampoline_US_DelFunc(void)
  1245. {
  1246.    US_DelFunc();
  1247. }
  1248. const struct EmulLibEntry Gate_US_DelFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_US_DelFunc };
  1249.  
  1250. void US_AddFunc(void);
  1251. static void  Trampoline_US_AddFunc(void)
  1252. {
  1253.    US_AddFunc();
  1254. }
  1255. const struct EmulLibEntry Gate_US_AddFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_US_AddFunc };
  1256.  
  1257. void US_OpenFunc(void);
  1258. static void  Trampoline_US_OpenFunc(void)
  1259. {
  1260.    US_OpenFunc();
  1261. }
  1262. const struct EmulLibEntry Gate_US_OpenFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_US_OpenFunc };
  1263.  
  1264. void US_CloseFunc(void);
  1265. static void  Trampoline_US_CloseFunc(void)
  1266. {
  1267.    US_CloseFunc();
  1268. }
  1269. const struct EmulLibEntry Gate_US_CloseFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_US_CloseFunc };
  1270.  
  1271. void US_GetUSEntryFunc(void);
  1272. static void  Trampoline_US_GetUSEntryFunc(void)
  1273. {
  1274.    US_GetUSEntryFunc();
  1275. }
  1276. const struct EmulLibEntry Gate_US_GetUSEntryFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_US_GetUSEntryFunc };
  1277.  
  1278. void US_PutUSEntryFunc(void);
  1279. static void  Trampoline_US_PutUSEntryFunc(void)
  1280. {
  1281.    US_PutUSEntryFunc();
  1282. }
  1283. const struct EmulLibEntry Gate_US_PutUSEntryFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_US_PutUSEntryFunc };
  1284.  
  1285. struct User;
  1286. struct User * US_LV_ConFunc(struct User *user);
  1287. static struct User *  Trampoline_US_LV_ConFunc(void)
  1288. {
  1289.    return US_LV_ConFunc((struct User *)REG_A1);
  1290. }
  1291. const struct EmulLibEntry Gate_US_LV_ConFunc = { TRAP_LIB, 0, (void(*)())Trampoline_US_LV_ConFunc };
  1292.  
  1293. struct User;
  1294. long US_LV_DspFunc(char **array, struct User *entry);
  1295. static long  Trampoline_US_LV_DspFunc(void)
  1296. {
  1297.    return US_LV_DspFunc((char **)REG_A2, (struct User *)REG_A1);
  1298. }
  1299. const struct EmulLibEntry Gate_US_LV_DspFunc = { TRAP_LIB, 0, (void(*)())Trampoline_US_LV_DspFunc };
  1300.  
  1301. long GeneralDesFunc(void *entry);
  1302. static long  Trampoline_GeneralDesFunc(void)
  1303. {
  1304.    return GeneralDesFunc((void *)REG_A1);
  1305. }
  1306. const struct EmulLibEntry Gate_GeneralDesFunc = { TRAP_LIB, 0, (void(*)())Trampoline_GeneralDesFunc };
  1307.  
  1308. void PO_SetPublicKey(APTR string, APTR pop);
  1309. static void  Trampoline_PO_SetPublicKey(void)
  1310. {
  1311.    PO_SetPublicKey((APTR)REG_A1, (APTR)REG_A2);
  1312. }
  1313. const struct EmulLibEntry Gate_PO_SetPublicKey = { TRAP_LIBNR, 0, (void(*)())Trampoline_PO_SetPublicKey };
  1314.  
  1315. long PO_ListPublicKeys(APTR string, APTR pop);
  1316. static long  Trampoline_PO_ListPublicKeys(void)
  1317. {
  1318.    return PO_ListPublicKeys((APTR)REG_A1, (APTR)REG_A2);
  1319. }
  1320. const struct EmulLibEntry Gate_PO_ListPublicKeys = { TRAP_LIB, 0, (void(*)())Trampoline_PO_ListPublicKeys };
  1321.  
  1322. void DisposeModuleFunc(void **arg);
  1323. static void  Trampoline_DisposeModuleFunc(void)
  1324. {
  1325.    DisposeModuleFunc((void **)REG_A1);
  1326. }
  1327. const struct EmulLibEntry Gate_DisposeModuleFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_DisposeModuleFunc };
  1328.  
  1329. struct Hook;
  1330. struct Locale;
  1331. void putCharFunc( struct Hook *hook,  char c,  struct Locale *locale);
  1332. static void  Trampoline_putCharFunc(void)
  1333. {
  1334.    putCharFunc((struct Hook *)REG_A0, (char)REG_A1, (struct Locale *)REG_A2);
  1335. }
  1336. const struct EmulLibEntry Gate_putCharFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_putCharFunc };
  1337.  
  1338. void WR_VerifyAutoFunc(int *arg);
  1339. static void  Trampoline_WR_VerifyAutoFunc(void)
  1340. {
  1341.    WR_VerifyAutoFunc((int *)REG_A1);
  1342. }
  1343. const struct EmulLibEntry Gate_WR_VerifyAutoFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_WR_VerifyAutoFunc };
  1344.  
  1345. void WR_VerifyManualFunc(int *arg);
  1346. static void  Trampoline_WR_VerifyManualFunc(void)
  1347. {
  1348.    WR_VerifyManualFunc((int *)REG_A1);
  1349. }
  1350. const struct EmulLibEntry Gate_WR_VerifyManualFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_WR_VerifyManualFunc };
  1351.  
  1352. void WR_GetFileEntry(int *arg);
  1353. static void  Trampoline_WR_GetFileEntry(void)
  1354. {
  1355.    WR_GetFileEntry((int *)REG_A1);
  1356. }
  1357. const struct EmulLibEntry Gate_WR_GetFileEntry = { TRAP_LIBNR, 0, (void(*)())Trampoline_WR_GetFileEntry };
  1358.  
  1359. void WR_PutFileEntry(int *arg);
  1360. static void  Trampoline_WR_PutFileEntry(void)
  1361. {
  1362.    WR_PutFileEntry((int *)REG_A1);
  1363. }
  1364. const struct EmulLibEntry Gate_WR_PutFileEntry = { TRAP_LIBNR, 0, (void(*)())Trampoline_WR_PutFileEntry };
  1365.  
  1366. void WR_NewMailFunc(int *arg);
  1367. static void  Trampoline_WR_NewMailFunc(void)
  1368. {
  1369.    WR_NewMailFunc((int *)REG_A1);
  1370. }
  1371. const struct EmulLibEntry Gate_WR_NewMailFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_WR_NewMailFunc };
  1372.  
  1373. void WR_CancelFunc(int *arg);
  1374. static void  Trampoline_WR_CancelFunc(void)
  1375. {
  1376.    WR_CancelFunc((int *)REG_A1);
  1377. }
  1378. const struct EmulLibEntry Gate_WR_CancelFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_WR_CancelFunc };
  1379.  
  1380. void WR_SaveAsFunc(int *arg);
  1381. static void  Trampoline_WR_SaveAsFunc(void)
  1382. {
  1383.    WR_SaveAsFunc((int *)REG_A1);
  1384. }
  1385. const struct EmulLibEntry Gate_WR_SaveAsFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_WR_SaveAsFunc };
  1386.  
  1387. void WR_Edit(int *arg);
  1388. static void  Trampoline_WR_Edit(void)
  1389. {
  1390.    WR_Edit((int *)REG_A1);
  1391. }
  1392. const struct EmulLibEntry Gate_WR_Edit = { TRAP_LIBNR, 0, (void(*)())Trampoline_WR_Edit };
  1393.  
  1394. void WR_AddFileFunc(int *arg);
  1395. static void  Trampoline_WR_AddFileFunc(void)
  1396. {
  1397.    WR_AddFileFunc((int *)REG_A1);
  1398. }
  1399. const struct EmulLibEntry Gate_WR_AddFileFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_WR_AddFileFunc };
  1400.  
  1401. void WR_AddArchiveFunc(int *arg);
  1402. static void  Trampoline_WR_AddArchiveFunc(void)
  1403. {
  1404.    WR_AddArchiveFunc((int *)REG_A1);
  1405. }
  1406. const struct EmulLibEntry Gate_WR_AddArchiveFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_WR_AddArchiveFunc };
  1407.  
  1408. void WR_DisplayFile(int *arg);
  1409. static void  Trampoline_WR_DisplayFile(void)
  1410. {
  1411.    WR_DisplayFile((int *)REG_A1);
  1412. }
  1413. const struct EmulLibEntry Gate_WR_DisplayFile = { TRAP_LIBNR, 0, (void(*)())Trampoline_WR_DisplayFile };
  1414.  
  1415. void WR_ChangeSignatureFunc(int *arg);
  1416. static void  Trampoline_WR_ChangeSignatureFunc(void)
  1417. {
  1418.    WR_ChangeSignatureFunc((int *)REG_A1);
  1419. }
  1420. const struct EmulLibEntry Gate_WR_ChangeSignatureFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_WR_ChangeSignatureFunc };
  1421.  
  1422. void WR_InsertSeparatorFunc(int *arg);
  1423. static void  Trampoline_WR_InsertSeparatorFunc(void)
  1424. {
  1425.    WR_InsertSeparatorFunc((int *)REG_A1);
  1426. }
  1427. const struct EmulLibEntry Gate_WR_InsertSeparatorFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_WR_InsertSeparatorFunc };
  1428.  
  1429. void WR_EditorCmd(int *arg);
  1430. static void  Trampoline_WR_EditorCmd(void)
  1431. {
  1432.    WR_EditorCmd((int *)REG_A1);
  1433. }
  1434. const struct EmulLibEntry Gate_WR_EditorCmd = { TRAP_LIBNR, 0, (void(*)())Trampoline_WR_EditorCmd };
  1435.  
  1436. void WR_AddClipboardFunc(int *arg);
  1437. static void  Trampoline_WR_AddClipboardFunc(void)
  1438. {
  1439.    WR_AddClipboardFunc((int *)REG_A1);
  1440. }
  1441. const struct EmulLibEntry Gate_WR_AddClipboardFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_WR_AddClipboardFunc };
  1442.  
  1443. void WR_AddPGPKeyFunc(int *arg);
  1444. static void  Trampoline_WR_AddPGPKeyFunc(void)
  1445. {
  1446.    WR_AddPGPKeyFunc((int *)REG_A1);
  1447. }
  1448. const struct EmulLibEntry Gate_WR_AddPGPKeyFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_WR_AddPGPKeyFunc };
  1449.  
  1450. void WR_UpdateWTitleFunc(int *arg);
  1451. static void  Trampoline_WR_UpdateWTitleFunc(void)
  1452. {
  1453.    WR_UpdateWTitleFunc((int *)REG_A1);
  1454. }
  1455. const struct EmulLibEntry Gate_WR_UpdateWTitleFunc = { TRAP_LIBNR, 0, (void(*)())Trampoline_WR_UpdateWTitleFunc };
  1456.  
  1457. LONG WR_AppFunc(ULONG *arg);
  1458. static LONG  Trampoline_WR_AppFunc(void)
  1459. {
  1460.    return WR_AppFunc((ULONG *)REG_A1);
  1461. }
  1462. const struct EmulLibEntry Gate_WR_AppFunc = { TRAP_LIB, 0, (void(*)())Trampoline_WR_AppFunc };
  1463.  
  1464. struct Attach;
  1465. struct Attach * WR_LV_ConFunc(struct Attach *attach);
  1466. static struct Attach *  Trampoline_WR_LV_ConFunc(void)
  1467. {
  1468.    return WR_LV_ConFunc((struct Attach *)REG_A1);
  1469. }
  1470. const struct EmulLibEntry Gate_WR_LV_ConFunc = { TRAP_LIB, 0, (void(*)())Trampoline_WR_LV_ConFunc };
  1471.  
  1472. struct Attach;
  1473. long WR_LV_DspFunc(char **array, struct Attach *entry);
  1474. static long  Trampoline_WR_LV_DspFunc(void)
  1475. {
  1476.    return WR_LV_DspFunc((char **)REG_A2, (struct Attach *)REG_A1);
  1477. }
  1478. const struct EmulLibEntry Gate_WR_LV_DspFunc = { TRAP_LIB, 0, (void(*)())Trampoline_WR_LV_DspFunc };
  1479.  
  1480.